package gjbsh.bangong.ds.controller;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;

import gjbsh.bangong.ds.model.*;
import gjbsh.bangong.ds.service.*;
import gjbsh.support.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.alibaba.druid.util.StringUtils;

import gjbsh.share.DeptType;

/**
 * @author yaolongjun
 * @date   2020年5月12日 下午2:56:27
 */
@RestController
@RequestMapping("dept")
public class 单位Controller {
	
	private Logger logger = LoggerFactory.getLogger(getClass());
	
	@Autowired
	单位Service ddService;
	
	@Autowired
	单位附加信息Service dd单位附加信息Service;
	
	@Autowired
	地区Service dd地区Service;
	
	@Autowired
	单位流动站Service dd单位流动站Service;
	
	@Autowired
	事务类型Service dd事务类型Service;

	@Autowired
	单位管理员Service dd单位管理员Service;

//	@RequestMapping("fenpeiguanliyuan")
//	public JsonResult<?> fenpeiguanliyuan(@RequestParam("piciid")String ppPiciID,
//										  @RequestParam("deptid")String ppDeptID,
//															 HttpServletRequest request){
//		try {
//			if("".equals(ppPiciID)) {
//				return JsonResult.getErrorResult("piciID不能为空");
//			}
//			if("".equals(ppDeptID)) {
//				return JsonResult.getErrorResult("单位ID不能为空");
//			}
//
//			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
//			if(loginUser == null) {
//				return JsonResult.getErrorResult("无登录信息");
//			}
//			String mmCurrentDeptId = loginUser.getDeptid() == null ? "" :loginUser.getDeptid();
//			if(!"1".equals(mmCurrentDeptId)) {
//				return JsonResult.getErrorResult("无此功能权限信息");
//			}
//			List<Map<String,Object>> mm需要分配集合 = ddService.findweifenpeibypiciid(ppDeptID+"%",ppPiciID);
//			for (int i = 0; i <mm需要分配集合.size() ; i++) {
//				Map<String,Object> mmone = mm需要分配集合.get(i);
//				单位管理员 mm管理员 = new 单位管理员();
//				用户 mm用户 = new 用户();
//				String mm用户id = mmone.get("用户ID") ==null?"":mmone.get("用户ID").toString();
//				String mm单位ID = mmone.get("单位ID") ==null?"":mmone.get("单位ID").toString();
//				String mm登录帐号 = mmone.get("登录帐号") ==null?"":mmone.get("登录帐号").toString();
//				String mm登录密码 = mmone.get("登录密码") ==null?"":mmone.get("登录密码").toString();
//				String mm用户名称 = mmone.get("用户名称") ==null?"":mmone.get("用户名称").toString();
//				String mm手机号码 = mmone.get("手机号码") ==null?"":mmone.get("手机号码").toString();
//				DESCryption des = new DESCryption();
//				mm登录密码 = "bsh_"+des.decode(mm登录密码);
//				mm用户.set用户id("gl"+mm用户id);
//				mm用户.set登录帐号("bsh_"+mm登录帐号);
//				mm用户.set用户名称(mm用户名称);
//				mm用户.set证件类型id("1");
//				mm用户.set证件号码("01234567890123456789012345678901234567890123456789");
//				mm用户.set是否锁定("100");
//				mm用户.set创建日期(new Date());
//				mm用户.set最后修改日期(new Date());
//				mm用户.set手机号码(mm手机号码);
//				mm用户.set是否更新识别码(BigDecimal.ZERO);
//
//				mm管理员.set单位管理员id(UUID.randomUUID().toString());
//				mm管理员.set单位id(mm单位ID);
//				mm管理员.set用户id("gl"+mm用户id);
//				mm管理员.set状态(new BigDecimal(100));
//				dd单位管理员Service.addCustom(mm管理员,mm用户,mm登录密码);
//				System.out.println(mm单位ID);
//			}
//			return JsonResult.getSuccessResult("完成");
//		} catch (Exception e) {
//			logger.error("单位Controller->fenpeiguanliyuan: "+e.getMessage());
//			return JsonResult.getErrorResult("失败");
//		}
//	}

	/**
	 * @author yaolongjun
	 * @description	根据单位ID查询单位 
	 */
	@RequestMapping("find_one")
	public JsonResult<?> find_one(@RequestParam("deptid")String ppDeptId){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			return JsonResult.getSuccessResult(ddService.findOne(ppDeptId));
		} catch (Exception e) {
			logger.error("单位Controller->find_one: "+e.getMessage());
			return JsonResult.getErrorResult("查询单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位ID查询单位 
	 */
	@RequestMapping("find_custom_by_deptid")
	public JsonResult<?> find_custom_by_deptid(@RequestParam("deptid")String ppDeptId){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			
			Map<String, Object> mmDept = ddService.findCustomByDeptId(ppDeptId);
			
			if(mmDept == null) {
				return JsonResult.getErrorResult("单位不存在");
			}
			
			String typeid = mmDept.get("单位类型ID") == null ? "" : mmDept.get("单位类型ID").toString();
			
			// 是否允许修改单位信息 
			mmDept.put("是否允许修改单位信息", DeptType.getAllowModifyDept(typeid));
			// 是否允许新增下级单位
			mmDept.put("是否允许新增下级单位", DeptType.getAllowAddSubDept(typeid));
			
			return JsonResult.getSuccessResult(mmDept);
		} catch (Exception e) {
			logger.error("单位Controller->find_custom_by_deptid: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位ID查询单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位ID查询下级单位类型，以及对应单位类型的单位 
	 */
	@RequestMapping("find_xjdw_and_xjdwleixing_by_deptid")
	public JsonResult<?> find_xjdw_and_xjdwleixing_by_deptid(@RequestParam("deptid")String ppDeptId,
			HttpServletRequest request){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			String mmCurrentDeptId = loginUser.getDeptid() == null ? "" :loginUser.getDeptid();
			if("".equals(mmCurrentDeptId)) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			单位 mmCurrnetDept = ddService.findOne(mmCurrentDeptId);
			if(mmCurrnetDept == null) {
				return JsonResult.getErrorResult("当前登录的单位不存在");
			}
			String mmCurrentDanweileixingId = mmCurrnetDept.get单位类型id();
			
			return JsonResult.getSuccessResult(ddService.findXjdwleixingAndXjdwByDeptId(ppDeptId,mmCurrentDanweileixingId));
		} catch (Exception e) {
			logger.error("单位Controller->find_xjdw_and_xjdwleixing_by_deptid: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位ID查询下级单位类型及对应单位类型的单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位所属详细部门ID查询部委直属下级单位 
	 */
	@RequestMapping("find_belong_to_organ_by_deptid")
	public JsonResult<?> find_belong_to_organ_by_deptid(@RequestParam("deptid")String ppDeptId){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			
			return JsonResult.getSuccessResult(ddService.findBelongToOrganByDeptId(ppDeptId));
		} catch (Exception e) {
			logger.error("单位Controller->find_belong_to_organ_by_deptid: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位所属详细部门ID查询部委直属下级单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位名称查找单位 
	 */
	@RequestMapping("find_custom_by_deptname")
	public JsonResult<?> find_custom_by_deptname(@RequestParam("deptname")String ppDeptName){
		try {
			ppDeptName = ppDeptName.trim();
			
			if("".equals(ppDeptName)) {
				return JsonResult.getErrorResult("单位名称不能为空");
			}else {
				ppDeptName = '%'+ppDeptName+'%';
			}
			
			return JsonResult.getSuccessResult(ddService.findCustomByDeptname(ppDeptName));
		} catch (Exception e) {
			logger.error("单位Controller->find_custom_by_deptname: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位名称查找单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	添加单位至部委
	 */
	@RequestMapping("add_dept_to_belong")
	public JsonResult<?> add_dept_to_belong(@RequestParam("deptid")String ppDeptId,
			@RequestParam("currentdeptssbmid")String ppCurrentdeptssbmid){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			if("".equals(ppCurrentdeptssbmid)) {
				return JsonResult.getErrorResult("单位所属部门ID不能为空");
			}
			
			// 查询当前单位的所属详细部门信息
			Map<String, Object> mmDeptFujiaxinxiMap = dd单位附加信息Service.findCustomByDeptId(ppDeptId);
			单位附加信息 mmDeptFujiaxinxi = null;
			boolean isNewAdd = false;
			if(mmDeptFujiaxinxiMap != null) {
				// 存在，则判断单位所属详细部门是否已加入
				String mmDeptSsxxbumenId = mmDeptFujiaxinxiMap.get("单位所属详细部门ID") == null ? "" : mmDeptFujiaxinxiMap.get("单位所属详细部门ID").toString();
				String mmDeptSsxxbumenMingcheng = mmDeptFujiaxinxiMap.get("单位所属详细部门名称") == null ? "" : mmDeptFujiaxinxiMap.get("单位所属详细部门名称").toString();
				
				if(!"".equals(mmDeptSsxxbumenId)) {
					return JsonResult.getErrorResult("该单位所属详细部门已加入到"+mmDeptSsxxbumenMingcheng);
				}
				
				// 未加入，则加入
				isNewAdd = false;
				mmDeptFujiaxinxi = dd单位附加信息Service.findOne(ppDeptId);
				mmDeptFujiaxinxi.set单位所属详细部门id(ppCurrentdeptssbmid);
			}else {
				// 不存在则新增
				isNewAdd = true;
				mmDeptFujiaxinxi = new 单位附加信息();
				mmDeptFujiaxinxi.set单位id(ppDeptId);
				mmDeptFujiaxinxi.set单位所属详细部门id(ppCurrentdeptssbmid);
				mmDeptFujiaxinxi.set状态(BigDecimal.valueOf(100));
			}
			
			if(isNewAdd) {
				// 新增单位_附加信息
				if(!dd单位附加信息Service.add(mmDeptFujiaxinxi)) {
					return JsonResult.getErrorResult("添加失败");
				}
				return JsonResult.getSuccessResult("添加成功");
			}else {
				// 修改单位_附加信息
				if(!dd单位附加信息Service.modify(mmDeptFujiaxinxi)) {
					return JsonResult.getErrorResult("添加失败");
				}
				return JsonResult.getSuccessResult("添加成功");
			}
		} catch (Exception e) {
			logger.error("单位Controller->add_dept_to_belong: "+e.getMessage());
			return JsonResult.getErrorResult("新增单位附加信息失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位类型ID查询可修改的单位类型list
	 */
	@RequestMapping("find_tongji_depttypelist_by_depttypeid")
	public JsonResult<?> find_tongji_depttypelist_by_depttypeid(@RequestParam("depttypeid")String ppDeptTypeId){
		try {
			if("".equals(ppDeptTypeId)) {
				return JsonResult.getErrorResult("单位类型ID不能为空");
			}
			
			List<DeptType> mmDeptTypeList = DeptType.getTongjiDeptTypeListByDeptTypeId(ppDeptTypeId);
			
			return JsonResult.getSuccessResult(mmDeptTypeList);
		} catch (Exception e) {
			logger.error("单位Controller->find_tongji_depttypelist_by_depttypeid: "+e.getMessage());
			return JsonResult.getErrorResult("根据类型单位ID查询统计单位类型列表失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位类型ID查询可修改的单位类型list
	 */
	@RequestMapping("find_sub_depttypelist_by_supdepttypeid")
	public JsonResult<?> find_sub_depttypelist_by_supdepttypeid(@RequestParam("depttypeid")String ppDeptTypeId){
		try {
			if("".equals(ppDeptTypeId)) {
				return JsonResult.getErrorResult("单位类型ID不能为空");
			}
			
			List<DeptType> mmDeptTypeList = DeptType.getSubDeptTypeListBySupDeptTypeId(ppDeptTypeId);
			
			return JsonResult.getSuccessResult(mmDeptTypeList);
		} catch (Exception e) {
			logger.error("单位Controller->find_sub_depttypelist_by_supdepttypeid: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位类型ID查询可修改的单位类型列表失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位类型ID查询该类型单位的扩展信息
	 */
	@RequestMapping("find_dept_expand_by_depttypeid")
	public JsonResult<?> find_dept_expand_by_depttypeid(@RequestParam("depttypeid")String ppDeptTypeId,
			HttpServletRequest request){
		try {
			Map<String,Object> mmDeptExpand = new HashMap<String,Object>();
			
			if("".equals(ppDeptTypeId)) {
				return JsonResult.getSuccessResult(mmDeptExpand);
			}
			
			BooleanMessage mmBooleanMessage = ddService.findDeptExpandByDeptTypeId(ppDeptTypeId,request);
			if(!mmBooleanMessage.isOk()) {
				return JsonResult.getErrorResult(mmBooleanMessage.getMessage().toString());
			}
			
			Map<String,Object> mmExpandMap = (Map<String, Object>) mmBooleanMessage.getMessage();
			// 是否允许设置流动站
			boolean mmShifouyunxuSetLiudongzhan = (boolean) mmExpandMap.get("IsSetL");
			// 是否允许从上级单位的池中选择流动站
			boolean mmShifouyunxuSelectLiudongzhan = (boolean) mmExpandMap.get("IsSelectL");
			// 是否允许设置单位扩展信息_工作站设站单位(独立招收资格)
			boolean mmShifouyunxuSetGongzuozhan = (boolean) mmExpandMap.get("IsSetG");
			
			// 不允许设置流动站时，是否允许显示流动站
			boolean mmShifouShowSetLiudongzhan = (boolean) mmExpandMap.get("IsShowSetL");
			
			String mmIsSetL = "";
			if(mmShifouyunxuSetLiudongzhan) {
				mmIsSetL = "1";
			}else if(mmShifouShowSetLiudongzhan) {
				mmIsSetL = "2";
			}else {
				mmIsSetL = "0";
			}
			
			mmDeptExpand.put("IsSetL", mmIsSetL);
			mmDeptExpand.put("IsSelectL", mmShifouyunxuSelectLiudongzhan ? "1" : "0");
			mmDeptExpand.put("IsSetG", mmShifouyunxuSetGongzuozhan ? "1" : "0");
			
			return JsonResult.getSuccessResult(mmDeptExpand);
		} catch (Exception e) {
			logger.error("单位Controller->find_dept_expand_by_depttypeid: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位类型ID查询该类型单位的扩展信息失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	新增
	 */
	@RequestMapping("add")
	public JsonResult<?> add(@RequestParam("deptid")String ppDeptId,
			@RequestParam("deptname")String ppDeptName,
			@RequestParam("depttypeid")String ppDeptTypeId,
			@RequestParam("deptssxxbumenid")String ppDeptSsxxbumenId,
			@RequestParam("shengfenid")String ppShengfenId,
			@RequestParam("diquid")String ppDiquId,
			@RequestParam("beizhu")String ppBeizhu,
			@RequestParam("zhuangtai")int ppZhuangtai,
			@RequestParam("deptliudongzhanids")String ppDeptliudongzhanids,
			@RequestParam("deptdulizhaoshou")int ppDeptdulizhaoshou,
			HttpServletRequest request){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			
			单位 mmSupDept = ddService.findOne(ppDeptId);
			if(mmSupDept == null) {
				return JsonResult.getErrorResult("上级单位不存在");
			}
			
			// 判断该上级单位能否添加该类型的下级单位
			String mmSupDeptTypeId = mmSupDept.get单位类型id();
			List<DeptType> mmSubDeptTypeList = DeptType.getSubDeptTypeListBySupDeptTypeId(mmSupDeptTypeId);
			if(mmSubDeptTypeList.size() < 1) {
				return JsonResult.getErrorResult("当前单位不能添加下级单位");
			}
			for(int i = 0; i < mmSubDeptTypeList.size(); i++) {
				if(ppDeptTypeId.equals(mmSubDeptTypeList.get(i).typeid)) {
					break;
				}else if(i == mmSubDeptTypeList.size()-1) {
					return JsonResult.getErrorResult("当前单位不能添加该类型的下级单位");
				}
			}
			
			// 查询重复单位
			List<单位> mmRecurDeptList = ddService.findRecurDept(ppDeptId,ppDeptName);
			if(mmRecurDeptList.size() > 0) {
				return JsonResult.getErrorResult("该单位已存在，不可重复添加");
			}

			单位 mmDept = new 单位();
			mmDept.set单位id(UUID.randomUUID().toString());
			mmDept.set上级单位id(ppDeptId);
			mmDept.set创建日期(new Date());
			
			// 检查数据合法性
			BooleanMessage mmBooleanMessage = checkInputData(mmDept,ppDeptName,ppDeptTypeId,ppDeptSsxxbumenId,
					ppShengfenId,ppDiquId,ppBeizhu,ppZhuangtai);
			if(!mmBooleanMessage.isOk()) {
				return JsonResult.getErrorResult(mmBooleanMessage.getMessage().toString());
			}
			
			// 判断是否允许修改单位扩展信息
			BooleanMessage mmBooleanMessage_expand = ddService.findDeptExpandByDeptTypeId(ppDeptTypeId,request);
			if(!mmBooleanMessage_expand.isOk()) {
				return JsonResult.getErrorResult(mmBooleanMessage_expand.getMessage().toString());
			}
			
			Map<String,Object> mmExpandMap = (Map<String, Object>) mmBooleanMessage_expand.getMessage();
			// 是否允许设置流动站
			boolean mmShifouyunxuSetLiudongzhan = (boolean) mmExpandMap.get("IsSetL");
			// 是否允许从上级单位的池中选择流动站
			boolean mmShifouyunxuSelectLiudongzhan = (boolean) mmExpandMap.get("IsSelectL");
			// 是否允许设置单位扩展信息_工作站设站单位(独立招收资格)
			boolean mmShifouyunxuSetGongzuozhan = (boolean) mmExpandMap.get("IsSetG");
			
			// 新增单位信息
			if(!ddService.addCustom(mmDept,ppDeptSsxxbumenId,ppDeptliudongzhanids,ppDeptdulizhaoshou,
					mmShifouyunxuSetLiudongzhan,mmShifouyunxuSelectLiudongzhan,mmShifouyunxuSetGongzuozhan)) {
				return JsonResult.getErrorResult("新增单位信息失败");
			}
			
			return JsonResult.getSuccessResult("新增单位信息成功");
		} catch (Exception e) {
			logger.error("单位Controller->add: "+e.getMessage());
			return JsonResult.getErrorResult("新增单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	修改
	 */
	@RequestMapping("modify")
	public JsonResult<?> modify(@RequestParam("deptid")String ppDeptId,
			@RequestParam("deptname")String ppDeptName,
			@RequestParam("depttypeid")String ppDeptTypeId,
			@RequestParam("deptssxxbumenid")String ppDeptSsxxbumenId,
			@RequestParam("shengfenid")String ppShengfenId,
			@RequestParam("diquid")String ppDiquId,
			@RequestParam("beizhu")String ppBeizhu,
			@RequestParam("zhuangtai")int ppZhuangtai,
			@RequestParam("deptliudongzhanids")String ppDeptliudongzhanids,
			@RequestParam("deptdulizhaoshou")int ppDeptdulizhaoshou,
			HttpServletRequest request){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			
			单位 mmDept = ddService.findOne(ppDeptId);
			if(mmDept == null) {
				return JsonResult.getErrorResult("要修改的单位不存在");
			}
			String mmDeptTypeId = mmDept.get单位类型id();
			if(StringUtils.isEmpty(mmDeptTypeId)) {
				return JsonResult.getErrorResult("要修改的单位类型数据异常");
			}
			
			// 是否允许修改单位信息 
			boolean shifoumodify = DeptType.getAllowModifyDept(mmDeptTypeId);
			if(!shifoumodify) {
				return JsonResult.getErrorResult("当前单位不能修改");
			}

			// 查登录单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			String mmLoginDeptId = loginUser.getDeptid();
			String mmLoginDepttypeId = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmLoginDepttypeId)) {
				return JsonResult.getErrorResult("登录单位类型数据异常");
			}
			
			// 是否修改本单位信息
			if(ppDeptId.equals(mmLoginDeptId) && !mmLoginDeptId.equals("1")) {
				return JsonResult.getErrorResult("当前单位不能修改");
			}
			
			// 当前登录单位为博管会
			if("0".equals(mmLoginDepttypeId)) {
				// 当前选中的单位允许修改本单位 且 非流动站下级单位
				if("30".equals(mmDeptTypeId)){
					shifoumodify = false;
				}
			}else {
				// 当前登录单位非博管会
				// 当前登录单位不是（试点省市、工作站总站、工作站企业、工作站分站、流动站下级单位）
				if("10".equals(mmLoginDepttypeId) || "25".equals(mmLoginDepttypeId) || "28".equals(mmLoginDepttypeId) 
						|| "30".equals(mmLoginDepttypeId) || "35".equals(mmLoginDepttypeId)) {
					shifoumodify = false;
				}
			}
			if(!shifoumodify) {
				return JsonResult.getErrorResult("当前单位不能修改");
			}
			
			// 判断当前单位能否修改为该类型单位
			List<DeptType> mmTongjiDeptTypeList = DeptType.getTongjiDeptTypeListByDeptTypeId(mmDept.get单位类型id());
			if(mmTongjiDeptTypeList.size() < 1) {
				return JsonResult.getErrorResult("当前单位不能修改为该类型单位");
			}
			for(int i = 0; i < mmTongjiDeptTypeList.size(); i++) {
				if(ppDeptTypeId.equals(mmTongjiDeptTypeList.get(i).typeid)) {
					break;
				}else if(i == mmTongjiDeptTypeList.size()-1){
					return JsonResult.getErrorResult("当前单位不能修改为该类型单位");
				}
			}
			
			String mmSupDeptId = mmDept.get上级单位id();
			// 查询重复单位
			List<单位> mmRecurDeptList = ddService.findRecurDept(mmSupDeptId,ppDeptName);
			for(int i = 0; i < mmRecurDeptList.size(); i++) {
				单位 mmRecurDept = mmRecurDeptList.get(i);
				if(mmRecurDept == null) {
					return JsonResult.getErrorResult("重复单位数据错误");
				}
				String mmDeptid = mmRecurDept.get单位id();
				if(!mmDeptid.equals(ppDeptId)) {
					return JsonResult.getErrorResult("该单位已存在，不可重复添加");
				}
			}
			
			// 检查数据合法性
			BooleanMessage mmBooleanMessage = checkInputData(mmDept,ppDeptName,ppDeptTypeId,ppDeptSsxxbumenId,
					ppShengfenId,ppDiquId,ppBeizhu,ppZhuangtai);
			if(!mmBooleanMessage.isOk()) {
				return JsonResult.getErrorResult(mmBooleanMessage.getMessage().toString());
			}
			
			// 判断是否允许修改单位扩展信息
			BooleanMessage mmBooleanMessage_expand = ddService.findDeptExpandByDeptTypeId(ppDeptTypeId,request);
			if(!mmBooleanMessage_expand.isOk()) {
				return JsonResult.getErrorResult(mmBooleanMessage_expand.getMessage().toString());
			}
			
			Map<String,Object> mmExpandMap = (Map<String, Object>) mmBooleanMessage_expand.getMessage();
			// 是否允许设置流动站
			boolean mmShifouyunxuSetLiudongzhan = (boolean) mmExpandMap.get("IsSetL");
			// 是否允许从上级单位的池中选择流动站
			boolean mmShifouyunxuSelectLiudongzhan = (boolean) mmExpandMap.get("IsSelectL");
			// 是否允许设置单位扩展信息_工作站设站单位(独立招收资格)
			boolean mmShifouyunxuSetGongzuozhan = (boolean) mmExpandMap.get("IsSetG");
			
			if(!ddService.modifyCustom(mmDept,ppDeptSsxxbumenId,ppDeptliudongzhanids,ppDeptdulizhaoshou,
					mmShifouyunxuSetLiudongzhan,mmShifouyunxuSelectLiudongzhan,mmShifouyunxuSetGongzuozhan)) {
				return JsonResult.getErrorResult("修改单位信息失败");
			}
			
			return JsonResult.getSuccessResult("修改单位信息成功");
		} catch (Exception e) {
			logger.error("单位Controller->modify: "+e.getMessage());
			return JsonResult.getErrorResult("修改单位失败");
		}
	}

	// 检查数据合法性
	private BooleanMessage checkInputData(单位 mmDept, String ppDeptName, String ppDeptTypeId, String ppDeptSsxxbumenId,
			String ppShengfenId, String ppDiquId, String ppBeizhu, int ppZhuangtai) {
		
		ppDeptName = ppDeptName.trim();
		ppDeptTypeId = ppDeptTypeId.trim();
		ppDeptSsxxbumenId = ppDeptSsxxbumenId.trim();
		ppShengfenId = ppShengfenId.trim();
		ppDiquId = ppDiquId.trim();
		ppBeizhu = ppBeizhu.trim();
		
		if("".equals(ppDeptName)) {
			return BooleanMessage.getErrorMessage("当前单位名称不能为空");
		}
		if(StringHandle.getStringByteLength(ppDeptName) > 255) {
			return BooleanMessage.getErrorMessage("当前单位名称不可超过255字节");
		}
		
		if("".equals(ppDeptTypeId)) {
			return BooleanMessage.getErrorMessage("单位类型不能为空");
		}
		if(StringHandle.getStringByteLength(ppDeptTypeId) > 50) {
			return BooleanMessage.getErrorMessage("单位名称不可超过50字节");
		}
		
		if("".equals(ppDeptSsxxbumenId)) {
			return BooleanMessage.getErrorMessage("所属部门不能为空");
		}
		if(StringHandle.getStringByteLength(ppDeptSsxxbumenId) > 50) {
			return BooleanMessage.getErrorMessage("所属部门不可超过50字节");
		}
		
		if("".equals(ppShengfenId)) {
			return BooleanMessage.getErrorMessage("省份不能为空");
		}
		if(StringHandle.getStringByteLength(ppShengfenId) > 50) {
			return BooleanMessage.getErrorMessage("省份不可超过50字节");
		}
		
		// 查询省份下有无地区，有则必填
		List<地区> mmDiquList = dd地区Service.findByShengfenId(ppShengfenId);
		if(mmDiquList.size() > 0) {
			if("".equals(ppDiquId)) {
				return BooleanMessage.getErrorMessage("地区不能为空");
			}
		}
		// 检查地区与省份是否对应
		for(int i = 0; i < mmDiquList.size(); i++) {
			String mmDiquId = mmDiquList.get(i).get地区id();
			if(ppDiquId.equals(mmDiquId)) {
				break;
			}else {
				if(i == mmDiquList.size()-1) {
					return BooleanMessage.getErrorMessage("请选择地区");
				}
			}
		}
		if(StringHandle.getStringByteLength(ppDiquId) > 50) {
			return BooleanMessage.getErrorMessage("地区不可超过50字节");
		}
		
		if(!"".equals(ppBeizhu)) {
			if(StringHandle.getStringByteLength(ppBeizhu) > 255) {
				return BooleanMessage.getErrorMessage("备注不可超过255字节");
			}
		}
		
		mmDept.set单位名称(ppDeptName);
		mmDept.set单位类型id(ppDeptTypeId);
		mmDept.set单位所属部门id(ppDeptSsxxbumenId);
		mmDept.set省份id(ppShengfenId);
		mmDept.set地区id(ppDiquId);
		mmDept.set备注(ppBeizhu);
		mmDept.set状态(BigDecimal.valueOf(ppZhuangtai));
		mmDept.set最后修改日期(new Date());
		
		return BooleanMessage.getSuccessMessage("输入信息合法");
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据省份ID和地区ID查询单位类型为（20，25，28）的单位 
	 */
	@RequestMapping("find_some_by_shengfenid_and_diquid")
	public JsonResult<?> find_some_by_shengfenid_and_diquid(@RequestParam("shengfenid")String ppShengfenId,
			@RequestParam("diquid")String ppDiquId){
		try {
			if("".equals(ppShengfenId)) {
				return JsonResult.getErrorResult("省份ID不能为空");
			}
			
			List<String> mmDepttypeIdList = new ArrayList<String>();
			mmDepttypeIdList.add(DeptType.流动站设站单位);
			mmDepttypeIdList.add(DeptType.工作站总站);
			mmDepttypeIdList.add(DeptType.工作站企业);
			
			// 根据单位类型和省份ID和地区ID查询单位
			List<Map<String,Object>> mmDeptList = ddService
					.findByDepttypeAndShengfenIdAndDiquId(mmDepttypeIdList,ppShengfenId,ppDiquId);
			
			return JsonResult.getSuccessResult(mmDeptList);
		} catch (Exception e) {
			logger.error("单位Controller->find_some_by_shengfenid_and_diquid: "+e.getMessage());
			return JsonResult.getErrorResult("根据省份ID和地区ID查询流动站设站单位、工作站企业和工作站总站失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位ID查询该单位的下级单位
	 */
	@RequestMapping("find_sub_dept_by_deptid")
	public JsonResult<?> find_sub_dept_by_deptid(@RequestParam("deptid")String ppDeptId){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			
			// 根据单位ID查询该单位的下级单位
			List<单位> mmDeptList = ddService.findSubDeptByDeptId(ppDeptId);
			
			return JsonResult.getSuccessResult(mmDeptList);
		} catch (Exception e) {
			logger.error("单位Controller->find_sub_dept_by_deptid: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位ID查询该单位的下级单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位ID查询该单位的下级单位
	 */
	@RequestMapping("find_is_exist_sub_dept")
	public JsonResult<?> find_is_exist_sub_dept(HttpServletRequest request){
		try {
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			String mmCurrentDeptId = loginUser.getDeptid() == null ? "" :loginUser.getDeptid();
			if("".equals(mmCurrentDeptId)) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			单位 mmCurrnetDept = ddService.findOne(mmCurrentDeptId);
			if(mmCurrnetDept == null) {
				return JsonResult.getErrorResult("当前登录的单位不存在");
			}
			String mmCurrentDanweileixingId = mmCurrnetDept.get单位类型id();
			
			boolean existSub = false;
			
			if(mmCurrentDanweileixingId.equals(DeptType.部委)) {
				existSub = true;
			}else {
				// 根据单位ID查询该单位的下级单位个数
				int mmDeptSize = ddService.countSubDeptByDeptId(mmCurrentDeptId);
				if(mmDeptSize > 0) {
					existSub = true;
				}
			}
			
			return JsonResult.getSuccessResult(existSub);
		} catch (Exception e) {
			logger.error("单位Controller->find_is_exist_sub_dept: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位ID查询该单位是否存在下级单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位名称查询该单位的下级单位
	 */
	@RequestMapping("find_sub_dept_by_deptname")
	public JsonResult<?> find_sub_dept_by_deptname(@RequestParam("deptname")String ppDeptName,
			HttpServletRequest request){
		try {
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			String mmCurrentDeptId = loginUser.getDeptid() == null ? "" :loginUser.getDeptid();
			if("".equals(mmCurrentDeptId)) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			Map<String, Object> mmCurrnetDept = ddService.findCustomByDeptId(mmCurrentDeptId);
			if(mmCurrnetDept == null) {
				return JsonResult.getErrorResult("当前登录的单位不存在");
			}
			
			ppDeptName = ppDeptName.trim();
			if("".equals(ppDeptName)) {
				return JsonResult.getErrorResult("要搜索的单位名称不能为空");
			}
			
			String mmCurrentDanweileixingId = mmCurrnetDept.get("单位类型ID") == null ? "" 
					: mmCurrnetDept.get("单位类型ID").toString();
			
			List<Map<String,Object>> mmSubDeptList = new ArrayList<Map<String,Object>>();
			
			if(mmCurrentDanweileixingId.equals(DeptType.部委)) {
				String ppSuosuXiangxibumenId = mmCurrnetDept.get("单位所属详细部门ID") == null ? "" 
						: mmCurrnetDept.get("单位所属详细部门ID").toString();
				
				mmSubDeptList = ddService.findBelongToOrganByDeptIdAndDeptname(ppSuosuXiangxibumenId,ppDeptName);
				
			}else {
				String ppXuliebianma = mmCurrnetDept.get("建制序列编码") == null ? "" 
						: mmCurrnetDept.get("建制序列编码").toString();
				if("".equals(ppXuliebianma)) {
					return JsonResult.getErrorResult("单位数据异常");
				}
				
				// 根据建制序列编码和单位名称查询下级单位
				mmSubDeptList = ddService.findSubdeptByXlbianmaAndDeptname(ppXuliebianma,ppDeptName);
			}
			
			return JsonResult.getSuccessResult(mmSubDeptList);
		} catch (Exception e) {
			logger.error("单位Controller->find_sub_dept_by_deptname: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位名称查询该单位的下级单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据省份ID和地区ID查询单位类型为（20）的单位 
	 */
	@RequestMapping("find_ldzshezhan_by_shengfenid_and_diquid")
	public JsonResult<?> find_ldzshezhan_by_shengfenid_and_diquid(@RequestParam("shengfenid")String ppShengfenId,
			@RequestParam("diquid")String ppDiquId){
		try {
			if("".equals(ppShengfenId)) {
				return JsonResult.getErrorResult("省份ID不能为空");
			}
			
			List<String> mmDepttypeIdList = new ArrayList<String>();
			mmDepttypeIdList.add(DeptType.流动站设站单位);
			
			// 根据单位类型和省份ID和地区ID查询单位
			List<Map<String,Object>> mmDeptList = ddService
					.findByDepttypeAndShengfenIdAndDiquId(mmDepttypeIdList,ppShengfenId,ppDiquId);
			
			return JsonResult.getSuccessResult(mmDeptList);
		} catch (Exception e) {
			logger.error("单位Controller->find_ldzshezhan_by_shengfenid_and_diquid: "+e.getMessage());
			return JsonResult.getErrorResult("根据省份ID和地区ID查询流动站设站单位的失败");
		}
	}
	
	
	/**
	 * @author yaolongjun
	 * @description	根据条件查询单位类型为10，15的省份单位
	 */
	@RequestMapping("find_shengdept")
	public JsonResult<?> find_shengdept(@RequestParam("shengname")String ppShengname){
		try {
			ppShengname = ppShengname.trim();
			if(!"".equals(ppShengname)) {
				ppShengname = "%" + ppShengname + "%";
			}
			
			List<Map<String,Object>> mmDeptList = ddService.findShengDept(ppShengname);
			return JsonResult.getSuccessResult(mmDeptList);
		} catch (Exception e) {
			logger.error("单位Controller->find_shengdept: "+e.getMessage());
			return JsonResult.getErrorResult("根据省份单位名称查询省份单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	按省统计单位（博管会和省份有这个功能）
	 */
	@RequestMapping("statistics_by_sheng")
	public JsonResult<?> statistics_by_sheng(@RequestParam("shengfenid")String ppShengfenId,
			HttpServletRequest request){
		try {
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			String mmDeptId = loginUser.getDeptid();
			String mmDeptType = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmDeptId) || StringUtils.isEmpty(mmDeptType)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			// 若当前单位非博管会或省份
			if(!mmDeptType.equals(DeptType.博管会) && !mmDeptType.equals(DeptType.试点省市) && !mmDeptType.equals(DeptType.非试点省市)) {
				return JsonResult.getErrorResult("当前单位无此统计功能");
			}
			
			// 定义存放单位统计结果的集合
			List<Map<String,Object>> mmDeptStatistics = new ArrayList<Map<String,Object>>();
			
			// 定义存放学科设站分布情况结果的集合
			List<Map<String,Object>> mmXuekeshezhanList = new ArrayList<Map<String,Object>>();
			
			// 定义存放工作站分站个数的对象
			int mmFenzhanNum = 0;
			
			// 若当前单位为博管会且未选择省份
			if(mmDeptType.equals(DeptType.博管会) && "".equals(ppShengfenId)) {
				// 统计所有省份的单位
				mmDeptStatistics = ddService.statisticsDeptOfAllSheng();
				
				// 统计所有省份的学科设站情况
				mmXuekeshezhanList = dd单位流动站Service.statisticsDeptLiudongzhanOfAllSheng();
				
				// 统计所有省份的工作站分站个数
				mmFenzhanNum = ddService.countGongzuozhanFenzhan("");
				
				
			}else {
				// 若当前单位非博管会，则当前单位为省份
				if(!mmDeptType.equals(DeptType.博管会)) {
					ppShengfenId = mmDeptId;
				}
				
				// 查询当前统计的省单位
				单位 mmShengDept = ddService.findOne(ppShengfenId);
				if(mmShengDept == null) {
					return JsonResult.getErrorResult("该单位不存在");
				}
				
				String mmJianzhiXlbm = mmShengDept.get建制序列编码();
				if(StringUtils.isEmpty(mmJianzhiXlbm)) {
					return JsonResult.getErrorResult("该单位序列编码未更新");
				}
				
				// 统计某一省份的单位
				mmDeptStatistics = ddService.statisticsDeptBySheng(ppShengfenId);
				
				// 若存在流动站设站单位，则统计该省份学科设站情况
				mmXuekeshezhanList = dd单位流动站Service.statisticsDeptLiudongzhanBySheng(ppShengfenId);
				
				// 统计该省份的工作站分站个数
				mmFenzhanNum = ddService.countGongzuozhanFenzhan(mmJianzhiXlbm+"%");
			}
			
			if(mmFenzhanNum > 0) {
				Map<String,Object> mmFenzhanMap = new HashMap<String,Object>();
				mmFenzhanMap.put("单位类型ID", DeptType.工作站分站);
				mmFenzhanMap.put("单位类型名称", DeptType.getDeptTypeNameByDeptTypeID(DeptType.工作站分站));
				mmFenzhanMap.put("单位数", mmFenzhanNum);
				
				if(mmDeptStatistics.size() > 2) {
					mmDeptStatistics.add(2, mmFenzhanMap);
				}else {
					mmDeptStatistics.add(mmFenzhanMap);
				}
			}
			
			// 定义存放返回结果的对象
			Map<String,Object> mmResultMap = new HashMap<String,Object>();
			mmResultMap.put("DeptStatistics", mmDeptStatistics);
			mmResultMap.put("XuekeshezhanList", mmXuekeshezhanList);
			
			return JsonResult.getSuccessResult(mmResultMap);
		} catch (Exception e) {
			logger.error("单位Controller->statistics_by_sheng: "+e.getMessage());
			return JsonResult.getErrorResult("按省份统计单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	按地区统计单位（博管会和省份有这个功能）
	 */
	@RequestMapping("statistics_by_diqu")
	public JsonResult<?> statistics_by_diqu(@RequestParam("shengfenid")String ppShengfenId,
			@RequestParam("diquid")String ppDiquId,
			HttpServletRequest request){
		try {
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			String mmDeptId = loginUser.getDeptid();
			String mmDeptType = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmDeptId) || StringUtils.isEmpty(mmDeptType)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			// 若当前单位非博管会或省份
			if(!mmDeptType.equals(DeptType.博管会) && !mmDeptType.equals(DeptType.试点省市) && !mmDeptType.equals(DeptType.非试点省市)) {
				return JsonResult.getErrorResult("当前单位无此统计功能");
			}
			
			// 定义存放单位统计结果的集合
			List<Map<String,Object>> mmDeptStatistics = new ArrayList<Map<String,Object>>();
			
			// 定义存放学科设站分布情况结果的集合
			List<Map<String,Object>> mmXuekeshezhanList = new ArrayList<Map<String,Object>>();
			
			// 定义存放工作站分站个数的对象
			int mmFenzhanNum = 0;
			
			// 若当前单位为博管会且未选择省份
			if(mmDeptType.equals(DeptType.博管会) && "".equals(ppShengfenId)) {
				// 统计所有省份的单位
				mmDeptStatistics = ddService.statisticsDeptOfAllSheng();
				
				// 统计所有省份的学科设站情况
				mmXuekeshezhanList = dd单位流动站Service.statisticsDeptLiudongzhanOfAllSheng();
				
				// 统计所有省份的工作站分站个数
				mmFenzhanNum = ddService.countGongzuozhanFenzhan("");
				
			}else {
				if("".equals(ppShengfenId)) {
					return JsonResult.getErrorResult("省份ID数据异常");
				}
				
				// 统计单位的所属省份和地区是该省份地区的设站单位
				mmDeptStatistics = ddService.statisticsDeptByShengfenIdAndDiquId(ppShengfenId,ppDiquId);
				
				// 若存在流动站设站单位，则统计该省份地区的学科设站情况
				boolean IsexitLdz = false;
				for(int i = 0; i < mmDeptStatistics.size(); i++) {
					String mmDanweileixingId = mmDeptStatistics.get(i).get("单位类型ID").toString();
					if(mmDanweileixingId.equals(DeptType.流动站设站单位)) {
						IsexitLdz = true;
						break;
					}
				}
				if(IsexitLdz) {
					// 统计该省份地区的学科设站情况
					mmXuekeshezhanList = dd单位流动站Service.statisticsDeptLiudongzhanByShengfenIdAndDiquId(ppShengfenId,ppDiquId);
				}
				
				// 统计该省份的工作站分站个数
//				mmFenzhanNum = ddService.countGongzuozhanFenzhan(mmJianzhiXlbm+"%");
			}
			
//			if(mmFenzhanNum > 0) {
//				Map<String,Object> mmFenzhanMap = new HashMap<String,Object>();
//				mmFenzhanMap.put("单位类型ID", DeptType.工作站分站);
//				mmFenzhanMap.put("单位类型名称", DeptType.getDeptTypeNameByDeptTypeID(DeptType.工作站分站));
//				mmFenzhanMap.put("单位数", mmFenzhanNum);
//				
//				if(mmDeptStatistics.size() > 2) {
//					mmDeptStatistics.add(2, mmFenzhanMap);
//				}else {
//					mmDeptStatistics.add(mmFenzhanMap);
//				}
//			}
			
			// 定义存放返回结果的对象
			Map<String,Object> mmResultMap = new HashMap<String,Object>();
			mmResultMap.put("DeptStatistics", mmDeptStatistics);
			mmResultMap.put("XuekeshezhanList", mmXuekeshezhanList);
			
			return JsonResult.getSuccessResult(mmResultMap);
		} catch (Exception e) {
			logger.error("单位Controller->statistics_by_diqu: "+e.getMessage());
			return JsonResult.getErrorResult("按地区统计单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	根据单位名称查找当前登录单位下的（流动站设站单位、工作站总站）
	 */
	@RequestMapping("find_headdept_by_deptname")
	public JsonResult<?> find_headdept_by_deptname(@RequestParam("deptname")String ppDeptname,
			HttpServletRequest request){
		try {
			ppDeptname = ppDeptname.trim();
			if("".equals(ppDeptname)) {
				return JsonResult.getErrorResult("请输入要查找的单位名称");
			}
			ppDeptname = "%" + ppDeptname + "%";
			
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			String mmDeptId = loginUser.getDeptid();
			if(StringUtils.isEmpty(mmDeptId)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			单位 mmDept = ddService.findOne(mmDeptId);
			if(mmDept == null) {
				return JsonResult.getErrorResult("登录单位不存在");
			}
			String mmJianzhiXlbm = mmDept.get建制序列编码();
			if(StringUtils.isEmpty(mmJianzhiXlbm)) {
				return JsonResult.getErrorResult("登录单位序列编码未更新");
			}
			
			List<Map<String,Object>> mmDeptList = ddService.findHeaddeptByDeptname(ppDeptname,mmJianzhiXlbm+"%");
			return JsonResult.getSuccessResult(mmDeptList);
		} catch (Exception e) {
			logger.error("单位Controller->find_headdept_by_deptname: "+e.getMessage());
			return JsonResult.getErrorResult("根据单位名称查询当前登录单位下的流动站设站单位、工作站总站失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	按单位统计单位（博管会、省份、工作站总站、流动站设站单位有这个功能）
	 */
	@RequestMapping("statistics_by_shezhandept")
	public JsonResult<?> statistics_by_shezhandept(@RequestParam("deptid")String ppDeptId,
			HttpServletRequest request){
		try {
			if("".equals(ppDeptId)) {
				return JsonResult.getErrorResult("单位ID不能为空");
			}
			
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			String mmDeptType = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmDeptType)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			// 若当前单位非博管会或省份
			if(!mmDeptType.equals(DeptType.博管会) && !mmDeptType.equals(DeptType.试点省市) 
					&& !mmDeptType.equals(DeptType.非试点省市) && !mmDeptType.equals(DeptType.工作站总站) 
					&& !mmDeptType.equals(DeptType.流动站设站单位)) {
				return JsonResult.getErrorResult("当前单位无此统计功能");
			}
			
			// 查询要统计的单位
			单位 mmDept = ddService.findOne(ppDeptId);
			if(mmDept == null) {
				return JsonResult.getErrorResult("要统计的单位不存在");
			}
			// 获取要统计的单位的单位类型
			String mmDeptTypeId = mmDept.get单位类型id();
			if(StringUtils.isEmpty(mmDeptTypeId)) {
				return JsonResult.getErrorResult("要统计的单位数据异常");
			}
			
			// 定义存放单位统计结果的集合
			List<Map<String,Object>> mmDeptStatistics = new ArrayList<Map<String,Object>>();
			
			// 定义存放学科设站分布情况结果的集合
			List<Map<String,Object>> mmXuekeshezhanList = new ArrayList<Map<String,Object>>();
			
			// 定义存放工作站分站的结果的集合
			List<Map<String,Object>> mmFenzhanList = new ArrayList<Map<String,Object>>();
			
			// 若要统计的单位为流动站设站单位
			if(mmDeptTypeId.equals(DeptType.流动站设站单位)) {
				// 根据单位ID统计该单位的学科设站情况
				mmXuekeshezhanList = dd单位流动站Service.statisticsDeptLiudongzhanByDeptId(ppDeptId);
				
				
				Map<String,Object> mmXuekeshezhanMap = new HashMap<String,Object>();
				mmXuekeshezhanMap.put("单位类型ID", DeptType.流动站下级单位);
				mmXuekeshezhanMap.put("单位类型名称", DeptType.getDeptTypeNameByDeptTypeID(DeptType.流动站下级单位));
				mmXuekeshezhanMap.put("单位数", mmXuekeshezhanList.size());
				
				mmDeptStatistics.add(mmXuekeshezhanMap);
			}else if(mmDeptTypeId.equals(DeptType.工作站总站)) {
				// 根据单位ID统计该单位的分站情况
				mmFenzhanList = ddService.statisticsFenzhanByDeptId(ppDeptId);
				
				Map<String,Object> mmFenzhanMap = new HashMap<String,Object>();
				mmFenzhanMap.put("单位类型ID", DeptType.工作站分站);
				mmFenzhanMap.put("单位类型名称", DeptType.getDeptTypeNameByDeptTypeID(DeptType.工作站分站));
				mmFenzhanMap.put("单位数", mmFenzhanList.size());
				
				mmDeptStatistics.add(mmFenzhanMap);
			}else {
				return JsonResult.getErrorResult("要统计的单位非流动站或工作站总站，无需统计");
			}
			
			// 定义存放返回结果的对象
			Map<String,Object> mmResultMap = new HashMap<String,Object>();
			mmResultMap.put("DeptStatistics", mmDeptStatistics);
			mmResultMap.put("XuekeshezhanList", mmXuekeshezhanList);
			mmResultMap.put("FenzhanList", mmFenzhanList);
			
			return JsonResult.getSuccessResult(mmResultMap);
		} catch (Exception e) {
			logger.error("单位Controller->statistics_by_shezhandept: "+e.getMessage());
			return JsonResult.getErrorResult("按单位统计单位失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	各省、直辖市博士后设站单位统计(20,25,28)（博管会有这个功能）
	 */
	@RequestMapping("statistics_shezhandept_groupby_sheng")
	public JsonResult<?> statistics_shezhandept_groupby_sheng(HttpServletRequest request){
		try {
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			String mmDeptId = loginUser.getDeptid();
			String mmDeptType = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmDeptId) || StringUtils.isEmpty(mmDeptType)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			// 若当前单位非博管会
			if(!mmDeptType.equals(DeptType.博管会)) {
				return JsonResult.getErrorResult("当前单位无此统计功能");
			}
			
			// 根据条件查询单位类型为10，15的省份单位
			List<Map<String,Object>> mmShengDeptList = ddService.findShengDept("");
			List<String> mmShengIdList = new ArrayList<String>();
			
			for(int i = 0; i < mmShengDeptList.size(); i++) {
				Map<String, Object> map = mmShengDeptList.get(i);
				String mmShengid = map.get("单位ID") == null ? "" : map.get("单位ID").toString();
				if(!"".equals(mmShengid)) {
					mmShengIdList.add(mmShengid);
				}
			}
			
			// 按省份计算所有的设站单位个数（20，25，28）
			List<Map<String,Object>> mmShezhanDept = ddService.countAllShezhanDeptGroupbySheng(mmShengIdList);
			
			// 定义存放学科设站分布情况结果的集合
			List<Map<String,Object>> mmXuekeshezhanList = dd单位流动站Service.countDeptLiudongzhanGroupbySheng(mmShengIdList);
			
			Map<String,Object> mmShengLdz = new HashMap<String,Object>();
			for(int i = 0; i < mmXuekeshezhanList.size(); i++) {
				Map<String, Object> mmXuekeshezhanMap = mmXuekeshezhanList.get(i);
				String mmSheng = mmXuekeshezhanMap.get("上级单位ID") == null ? "" 
						: mmXuekeshezhanMap.get("上级单位ID").toString();
			
				String mmLdzshu = mmXuekeshezhanMap.get("站点个数") == null ? "" 
						: mmXuekeshezhanMap.get("站点个数").toString();
				
				mmShengLdz.put(mmSheng, mmLdzshu);
			}
			
			// 定义存放单位统计结果的集合
			List<Map<String,Object>> mmDeptStatistics = new ArrayList<Map<String,Object>>();
			
			int zongldzdeptshu = 0;		// 总流动站单位数量
			int zongldzshu = 0;			// 总流动站数量
			int zonggzzshu = 0;			// 总工作站数量 
			
			// 循环省份单位，补全该省份的设站单位个数
			for(int i = 0; i < mmShengDeptList.size(); i++) {
				Map<String, Object> shengDept = mmShengDeptList.get(i);
				String mmShengid = shengDept.get("单位ID") == null ? "" : shengDept.get("单位ID").toString();
				
				// 当省份为北京市属和中央在京，移除
				if("001-A1A1A1A1A1".equals(mmShengid) || "001-B2B2B2B2B2".equals(mmShengid)) {
					mmShengDeptList.remove(i);
					i--;
					continue;
				}
				
				int ldzdeptshu = 0;		// 流动站单位数量
				int ldzshu = 0;			// 流动站数量
				int gzzshu = 0;			// 工作站数量
				
				// 当省份为北京市，取北京市属和中央在京的总数
				if("001".equals(mmShengid)) {
					int shishu = mmShengLdz.get("001-A1A1A1A1A1") == null ? 0 
							: Integer.parseInt(mmShengLdz.get("001-A1A1A1A1A1").toString());
					int zaijing = mmShengLdz.get("001-B2B2B2B2B2") == null ? 0 
							: Integer.parseInt(mmShengLdz.get("001-B2B2B2B2B2").toString());
					
					ldzshu = shishu + zaijing;
					
				}else {
					ldzshu = mmShengLdz.get(mmShengid) == null ? 0 
							: Integer.parseInt(mmShengLdz.get(mmShengid).toString());
				}
				
				
				
				// 循环设站单位
				for(int j = 0; j < mmShezhanDept.size(); j++) {
					Map<String, Object> mmShezhanDeptMap = mmShezhanDept.get(j);
					
					String mmSheng = mmShezhanDeptMap.get("上级单位ID") == null ? "" 
							: mmShezhanDeptMap.get("上级单位ID").toString();
					
					// 是否循环
					boolean exist = false;
					
					// 当省份为北京市，取北京市属和中央在京的总数
					if("001".equals(mmShengid)) {
						if("001-A1A1A1A1A1".equals(mmSheng) || "001-B2B2B2B2B2".equals(mmSheng)) {
							exist = true;
						}
					}else if(mmShengid.equals(mmSheng)) {
						exist = true;
					}
					
					if(exist) {
						
						String mmDanweileixing = mmShezhanDeptMap.get("单位类型ID") == null ? "" 
								: mmShezhanDeptMap.get("单位类型ID").toString();
						
						int mmDanweishu = mmShezhanDeptMap.get("单位数") == null ? 0 
								: Integer.parseInt(mmShezhanDeptMap.get("单位数").toString());
						
						if(mmDanweileixing.equals(DeptType.流动站设站单位)) {
							ldzdeptshu = ldzdeptshu + mmDanweishu;
						}else if(mmDanweileixing.equals(DeptType.工作站总站) || mmDanweileixing.equals(DeptType.工作站企业)) {
							gzzshu = gzzshu + mmDanweishu;
						}
						
					}
				}
				
				shengDept.put("流动站单位数量", ldzdeptshu);
				shengDept.put("流动站数量", ldzshu);
				shengDept.put("工作站数量", gzzshu);
				
				// 总流动站数量
				zongldzshu = zongldzshu + ldzshu;
				// 总流动站单位数量
				zongldzdeptshu = zongldzdeptshu + ldzdeptshu;	
				// 总工作站数量
				zonggzzshu = zonggzzshu + gzzshu;
				
				mmDeptStatistics.add(shengDept);
			}
			
			// 把总数加上
			Map<String, Object> mmZongji = new HashMap<String,Object>();
			mmZongji.put("单位名称", "合计");
			mmZongji.put("流动站单位数量", zongldzdeptshu);
			mmZongji.put("流动站数量", zongldzshu);
			mmZongji.put("工作站数量", zonggzzshu);
			
			mmDeptStatistics.add(mmZongji);
			
			return JsonResult.getSuccessResult(mmDeptStatistics);
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("单位Controller->statistics_shezhandept_groupby_sheng: "+e.getMessage());
			return JsonResult.getErrorResult("各省、直辖市博士后设站单位统计失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	统计各省、直辖市各招收类型的招收人数（博管会有这个功能）
	 */
	@RequestMapping("statistics_zhaoshourenshu_groupby_sheng")
	public JsonResult<?> statistics_zhaoshourenshu_groupby_sheng(@RequestParam("starttime") String ppStartTime,
			@RequestParam("endtime") String ppEndTime,
			HttpServletRequest request){
		try {
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			String mmDeptId = loginUser.getDeptid();
			String mmDeptType = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmDeptId) || StringUtils.isEmpty(mmDeptType)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			// 若当前单位非博管会
			if(!mmDeptType.equals(DeptType.博管会)) {
				return JsonResult.getErrorResult("当前单位无此统计功能");
			}
			
			ppStartTime = ppStartTime.trim();
			ppEndTime = ppEndTime.trim();
			
			if(!"".equals(ppStartTime)) {
				ppStartTime = ppStartTime + " 00:00:00";
			}
			if(!"".equals(ppEndTime)) {
				ppEndTime = ppEndTime + " 23:59:59";
			}
			
			// 根据条件查询单位类型为10，15的省份单位
			List<Map<String,Object>> mmShengDeptList = ddService.findShengDept("");
			
			// 查询所有进站类型
			List<事务类型> mmJzLeixingList = dd事务类型Service.findValidByLeibieId("1");
			
			// 计算各省、直辖市各招收类型的招收人数
			List<Map<String,Object>> mmZhaoshouList = ddService
					.countZhaoshourenshuGroupbyShengAndLeixing(ppStartTime,ppEndTime);
			
			// 定义存放招收人数统计结果的集合
			List<Map<String,Object>> mmZhaoshouStatistics = new ArrayList<Map<String,Object>>();
			
			// 循环省份单位，补全该省份的招收人数
			for(int i = 0; i < mmShengDeptList.size(); i++) {
				Map<String, Object> shengDept = mmShengDeptList.get(i);
				String mmShengid = shengDept.get("单位ID") == null ? "" : shengDept.get("单位ID").toString();
				
				// 当省份为北京市属和中央在京，移除
				if("001-A1A1A1A1A1".equals(mmShengid) || "001-B2B2B2B2B2".equals(mmShengid)) {
					mmShengDeptList.remove(i);
					i--;
					continue;
				}
				
				// 定义存放某省份的进站类型集合
				Map<String,Object> mmShengJzLeixingMap = new HashMap<String,Object>(); 
				
				// 某省份的招收人数
				int shengzhaoshourenshu = 0;
				
				// 循环所有进站类型
				for(int m = 0; m < mmJzLeixingList.size(); m++) {
					事务类型 mmJzLeixing = mmJzLeixingList.get(m);
					String dangqianjzleixingId = mmJzLeixing.get事务类型id();
					String dangqianjzleixingmingcheng = mmJzLeixing.get事务类型名称();
					
					if("018".equals(dangqianjzleixingId)) {
						continue;
					}
					
					int dangqianjzlxshu = 0;
					
					// 循环各省、直辖市各进站类型招收人数
					for(int j = 0; j < mmZhaoshouList.size(); j++) {
						Map<String, Object> mmZhaoshouMap = mmZhaoshouList.get(j);
						
						String mmSheng = mmZhaoshouMap.get("进站省市ID") == null ? "" 
								: mmZhaoshouMap.get("进站省市ID").toString();
						String mmJzleixing = mmZhaoshouMap.get("事务类型ID") == null ? "" 
								: mmZhaoshouMap.get("事务类型ID").toString();
						
						// 是否循环
						boolean exist = false;
						
						// 当省份为北京市，取北京市属和中央在京的总数
						if("001".equals(mmShengid)) {
							if("001-A1A1A1A1A1".equals(mmSheng) || "001-B2B2B2B2B2".equals(mmSheng)) {
								exist = true;
							}
						}else if(mmShengid.equals(mmSheng)) {
							exist = true;
						}
						
						// 并且是当前进站类型
						if(exist && mmJzleixing.equals(dangqianjzleixingId)) {
							exist = true;
						}else {
							exist = false;
						}
						
						if(exist) {
							int mmCount = mmZhaoshouMap.get("招收人数") == null ? 0 
									: Integer.parseInt(mmZhaoshouMap.get("招收人数").toString());
							
							dangqianjzlxshu = dangqianjzlxshu + mmCount;
						}
					}
					
					mmShengJzLeixingMap.put(dangqianjzleixingmingcheng, dangqianjzlxshu);
					
					// 某省份的招收总人数
					shengzhaoshourenshu = shengzhaoshourenshu + dangqianjzlxshu;
					
				}
				
				mmShengJzLeixingMap.put("省招收人数", shengzhaoshourenshu);
				
				shengDept.put("省进站类型集合", mmShengJzLeixingMap);
				
				mmZhaoshouStatistics.add(shengDept);
			}
			
			return JsonResult.getSuccessResult(mmZhaoshouStatistics);
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("单位Controller->statistics_zhaoshourenshu_groupby_sheng: "+e.getMessage());
			return JsonResult.getErrorResult("各省、直辖市招收人数统计失败");
		}
	}
	
	/**
	 * @author yaolongjun
	 * @description	统计各省、直辖市博士后进站身份类型（博管会有这个功能）
	 */
	@RequestMapping("statistics_jzshenfen_groupby_sheng")
	public JsonResult<?> statistics_jzshenfen_groupby_sheng(@RequestParam("starttime") String ppStartTime,
			@RequestParam("endtime") String ppEndTime,
			HttpServletRequest request){
		try {
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			String mmDeptId = loginUser.getDeptid();
			String mmDeptType = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmDeptId) || StringUtils.isEmpty(mmDeptType)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			// 若当前单位非博管会
			if(!mmDeptType.equals(DeptType.博管会)) {
				return JsonResult.getErrorResult("当前单位无此统计功能");
			}
			
			ppStartTime = ppStartTime.trim();
			ppEndTime = ppEndTime.trim();
			
			if(!"".equals(ppStartTime)) {
				ppStartTime = ppStartTime + " 00:00:00";
			}
			if(!"".equals(ppEndTime)) {
				ppEndTime = ppEndTime + " 23:59:59";
			}
			
			// 根据条件查询单位类型为10，15的省份单位
			List<Map<String,Object>> mmShengDeptList = ddService.findShengDept("");
			
			// 列出所有进站身份
			List<String> mmShenfenIdList = new ArrayList<String>();
			for(int i = 1; i < 12; i++) {
				mmShenfenIdList.add(i+"");
			}
			
			// 计算各省、直辖市博士后进站身份类型
			List<Map<String,Object>> mmJzshenfenList = ddService.countJzshenfenGroupbySheng(ppStartTime,ppEndTime);
			
			// 定义存放进站身份类型统计结果的集合
			List<Map<String,Object>> mmJzshenfenStatistics = new ArrayList<Map<String,Object>>();
			
			// 循环省份单位，补全该省份的进站身份类型人数
			for(int i = 0; i < mmShengDeptList.size(); i++) {
				Map<String, Object> shengDept = mmShengDeptList.get(i);
				String mmShengid = shengDept.get("单位ID") == null ? "" : shengDept.get("单位ID").toString();
				
				// 当省份为北京市属和中央在京，移除
				if("001-A1A1A1A1A1".equals(mmShengid) || "001-B2B2B2B2B2".equals(mmShengid)) {
					mmShengDeptList.remove(i);
					i--;
					continue;
				}
				
				// 定义存放某省份的进站身份类型集合
				Map<String,Object> mmShengJzShenfenMap = new HashMap<String,Object>(); 
				
				// 循环身份类型，取出该省份当前身份类型的人数
				for(int m = 0; m < mmShenfenIdList.size(); m++) {
					String dangqianshenfenid = mmShenfenIdList.get(m);
					
					int dangqianshenfenshu = 0;
					
					// 循环各省、直辖市进站身份类型列表
					for(int j = 0; j < mmJzshenfenList.size(); j++) {
						Map<String, Object> mmJzshenfenMap = mmJzshenfenList.get(j);
						
						String mmSheng = mmJzshenfenMap.get("进站省市ID") == null ? "" 
								: mmJzshenfenMap.get("进站省市ID").toString();
						String mmShenfen = mmJzshenfenMap.get("申请人当前身份ID") == null ? "" 
								: mmJzshenfenMap.get("申请人当前身份ID").toString();
						
						// 是否循环
						boolean exist = false;
						
						// 当省份为北京市，取北京市属和中央在京的总数
						if("001".equals(mmShengid)) {
							if("001-A1A1A1A1A1".equals(mmSheng) || "001-B2B2B2B2B2".equals(mmSheng)) {
								exist = true;
							}
						}else if(mmShengid.equals(mmSheng)) {
							exist = true;
						}
						
						// 并且是当前进站身份
						if(exist && mmShenfen.equals(dangqianshenfenid)) {
							exist = true;
						}else {
							exist = false;
						}
						
						// 统计当前省份的当前身份的人数
						if(exist) {
							int mmCount = mmJzshenfenMap.get("人数") == null ? 0 
									: Integer.parseInt(mmJzshenfenMap.get("人数").toString());
							
							dangqianshenfenshu = dangqianshenfenshu + mmCount;
						}
					}
					
					mmShengJzShenfenMap.put(dangqianshenfenid, dangqianshenfenshu);
					
				}
				
				shengDept.put("省进站身份集合", mmShengJzShenfenMap);
				
				mmJzshenfenStatistics.add(shengDept);
				
			}
			
			return JsonResult.getSuccessResult(mmJzshenfenStatistics);
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("单位Controller->statistics_jzshenfen_groupby_sheng: "+e.getMessage());
			return JsonResult.getErrorResult("各省、直辖市招收人数统计失败");
		}
	}
	
	
	/**
	 * @author yaolongjun
	 * @description	按招收类型统计各省、直辖市在站人数（博管会有这个功能）
	 */
	@RequestMapping("statistics_zaizhanrenshu_groupby_sheng")
	public JsonResult<?> statistics_zaizhanrenshu_groupby_sheng(@RequestParam("starttime") String ppStartTime,
			@RequestParam("endtime") String ppEndTime,
			HttpServletRequest request){
		try {
			// 取当前登录用户的单位
			LoginUser loginUser = (LoginUser)request.getAttribute(AppGlobalConfig.REQUEST_LOGINUSER_NAME);
			if(loginUser == null) {
				return JsonResult.getErrorResult("无登录信息");
			}
			
			String mmDeptId = loginUser.getDeptid();
			String mmDeptType = loginUser.getDeptType();
			if(StringUtils.isEmpty(mmDeptId) || StringUtils.isEmpty(mmDeptType)) {
				return JsonResult.getErrorResult("登录信息数据异常");
			}
			
			// 若当前单位非博管会
			if(!mmDeptType.equals(DeptType.博管会)) {
				return JsonResult.getErrorResult("当前单位无此统计功能");
			}
			
//			ppStartTime = ppStartTime.trim();
//			ppEndTime = ppEndTime.trim();
//			
//			if(!"".equals(ppStartTime)) {
//				ppStartTime = ppStartTime + " 00:00:00";
//			}
//			if(!"".equals(ppEndTime)) {
//				ppEndTime = ppEndTime + " 23:59:59";
//			}
			
			// 根据条件查询单位类型为10，15的省份单位
			List<Map<String,Object>> mmShengDeptList = ddService.findShengDept("");
			
			// 查询所有进站类型
			List<事务类型> mmJzLeixingList = dd事务类型Service.findValidByLeibieId("1");
			
			// 计算各省、直辖市各招收类型的在站人数
			List<Map<String,Object>> mmZaizhanList = ddService.countZaizhanrenshuGroupbyShengAndLeixing();
			
			// 定义存放在站人数统计结果的集合
			List<Map<String,Object>> mmZaizhanStatistics = new ArrayList<Map<String,Object>>();
			
			// 循环省份单位，补全该省份的在站人数
			for(int i = 0; i < mmShengDeptList.size(); i++) {
				Map<String, Object> shengDept = mmShengDeptList.get(i);
				String mmShengid = shengDept.get("单位ID") == null ? "" : shengDept.get("单位ID").toString();
				
				// 当省份为北京市属和中央在京，移除
				if("001-A1A1A1A1A1".equals(mmShengid) || "001-B2B2B2B2B2".equals(mmShengid)) {
					mmShengDeptList.remove(i);
					i--;
					continue;
				}
				
				// 定义存放某省份的在站博士后进站类型集合
				Map<String,Object> mmShengJzLeixingMap = new HashMap<String,Object>(); 
				
				// 某省份的在站人数
				int shengzaizhanrenshu = 0;
				
				// 循环所有进站类型
				for(int m = 0; m < mmJzLeixingList.size(); m++) {
					事务类型 mmJzLeixing = mmJzLeixingList.get(m);
					String dangqianjzleixingId = mmJzLeixing.get事务类型id();
					String dangqianjzleixingmingcheng = mmJzLeixing.get事务类型名称();
					
					if("018".equals(dangqianjzleixingId)) {
						continue;
					}
					
					int dangqianjzlxshu = 0;
					
					// 循环各省、直辖市各进站类型在站人数
					for(int j = 0; j < mmZaizhanList.size(); j++) {
						Map<String, Object> mmZaizhanMap = mmZaizhanList.get(j);
						
						String mmSheng = mmZaizhanMap.get("进站省市ID") == null ? "" 
								: mmZaizhanMap.get("进站省市ID").toString();
						String mmJzleixing = mmZaizhanMap.get("事务类型ID") == null ? "" 
								: mmZaizhanMap.get("事务类型ID").toString();
						
						// 是否循环
						boolean exist = false;
						
						// 当省份为北京市，取北京市属和中央在京的总数
						if("001".equals(mmShengid)) {
							if("001-A1A1A1A1A1".equals(mmSheng) || "001-B2B2B2B2B2".equals(mmSheng)) {
								exist = true;
							}
						}else if(mmShengid.equals(mmSheng)) {
							exist = true;
						}
						
						// 并且是当前进站类型
						if(exist && mmJzleixing.equals(dangqianjzleixingId)) {
							exist = true;
						}else {
							exist = false;
						}
						
						if(exist) {
							int mmCount = mmZaizhanMap.get("在站人数") == null ? 0 
									: Integer.parseInt(mmZaizhanMap.get("在站人数").toString());
							
							dangqianjzlxshu = dangqianjzlxshu + mmCount;
						}
					}
					
					mmShengJzLeixingMap.put(dangqianjzleixingmingcheng, dangqianjzlxshu);
					
					// 某省份的在站总人数
					shengzaizhanrenshu = shengzaizhanrenshu + dangqianjzlxshu;
					
				}
				
				mmShengJzLeixingMap.put("省在站人数", shengzaizhanrenshu);
				
				shengDept.put("省进站类型集合", mmShengJzLeixingMap);
				
				mmZaizhanStatistics.add(shengDept);
			}
			
			return JsonResult.getSuccessResult(mmZaizhanStatistics);
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("单位Controller->statistics_zaizhanrenshu_groupby_sheng: "+e.getMessage());
			return JsonResult.getErrorResult("各省、直辖市在站人数统计失败");
		}
	}
	
	/**
	 * @author hwx
	 * @description	更新所有单位的建制序列编码
	 */
	@RequestMapping("modify_jianzhixuliebm")
	public JsonResult<?> modify_jianzhixuliebm(){
		try {
			ddService.updateJianzhixuliebm("1","001");
			return JsonResult.getSuccessResult("");
		} catch (Exception e) {
			logger.error("单位Controller->modify_jianzhixuliebm: "+e.getMessage());
			return JsonResult.getErrorResult("更新所有单位的建制序列编码失败");
		}
	}
}
